home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / bash-1.12 / dist / builtins / umask.def < prev    next >
Encoding:
Text File  |  1992-01-07  |  6.2 KB  |  284 lines
  1. This file is umask.def, from which is created umask.c.
  2. It implements the builtin "umask" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES umask.c
  23.  
  24. $BUILTIN umask
  25. $FUNCTION umask_builtin
  26. $SHORT_DOC umask [-S] [mode]
  27. The user file-creation mask is set to MODE.  If MODE is omitted, or if
  28. `-S' is supplied, the current value of the mask is printed.  The `-S'
  29. option makes the output symbolic; otherwise an octal number is output.
  30. If MODE begins with a digit, it is interpreted as an octal number,
  31. otherwise it is a symbolic mode string like that accepted by chmod(1).
  32. $END
  33.  
  34. #include <stdio.h>
  35. #include <sys/types.h>
  36. #include <sys/file.h>
  37. #include "../shell.h"
  38. #include "../posixstat.h"
  39.  
  40. /* **************************************************************** */
  41. /*                                                                  */
  42. /*                     UMASK Builtin and Helpers                    */
  43. /*                                                                  */
  44. /* **************************************************************** */
  45.  
  46. static void print_symbolic_umask ();
  47. static int symbolic_umask ();
  48.  
  49. /* Set or display the mask used by the system when creating files.  Flag
  50.    of -S means display the umask in a symbolic mode. */
  51.    
  52. umask_builtin (list)
  53.      WORD_LIST *list;
  54. {
  55.   while (list)
  56.     {
  57.       if (strcmp (list->word->word, "-S") == 0)
  58.     {
  59.       int um;
  60.  
  61.       um = umask (022);
  62.       umask (um);
  63.       print_symbolic_umask (um);
  64.       list = list->next;
  65.       continue;
  66.     }
  67.       else if (strcmp (list->word->word, "--") == 0)
  68.     {
  69.       list = list->next;
  70.       break;
  71.     }
  72.       else if (*(list->word->word) == '-')
  73.     {
  74.       bad_option (list->word->word);
  75.       return (-1);
  76.     }
  77.       else
  78.     break;
  79.     }
  80.  
  81.   if (list)
  82.     {
  83.       int new_umask;
  84.  
  85.       if (digit (*list->word->word))
  86.     {
  87.       new_umask = read_octal (list->word->word);
  88.  
  89.       /* Note that other shells just let you set the umask to zero
  90.          by specifying a number out of range.  This is a problem
  91.          with those shells.  We don't change the umask if the input
  92.          is lousy. */
  93.       if (new_umask == -1)
  94.         {
  95.           builtin_error ("`%s' is not an octal number from 000 to 777",
  96.                 list->word->word);
  97.           return (EXECUTION_FAILURE);
  98.         }
  99.     }
  100.       else
  101.     {
  102.       new_umask = symbolic_umask (list);
  103.       if (new_umask == -1)
  104.         return (EXECUTION_FAILURE);
  105.     }
  106.       umask (new_umask);
  107.     }
  108.   else
  109.     {
  110.       /* Display the UMASK for this user. */
  111.       int old_umask = umask (022);
  112.       umask (old_umask);
  113.       printf ("%03o\n", old_umask);
  114.     }
  115.   fflush (stdout);
  116.   return (EXECUTION_SUCCESS);
  117. }
  118.  
  119. /* Print the umask in a symbolic form.  In the output, a letter is
  120.    printed if the corresponding bit is clear in the umask. */
  121. static void
  122. print_symbolic_umask (um)
  123.      int um;
  124. {
  125.   char ubits[4], gbits[4], obits[4];        /* u=rwx,g=rwx,o=rwx */
  126.   int i;
  127.  
  128.   i = 0;
  129.   if ((um & S_IRUSR) == 0)
  130.     ubits[i++] = 'r';
  131.   if ((um & S_IWUSR) == 0)
  132.     ubits[i++] = 'w';
  133.   if ((um & S_IXUSR) == 0)
  134.     ubits[i++] = 'x';
  135.   ubits[i] = '\0';
  136.  
  137.   i = 0;
  138.   if ((um & S_IRGRP) == 0)
  139.     gbits[i++] = 'r';
  140.   if ((um & S_IWGRP) == 0)
  141.     gbits[i++] = 'w';
  142.   if ((um & S_IXGRP) == 0)
  143.     gbits[i++] = 'x';
  144.   gbits[i] = '\0';
  145.  
  146.   i = 0;
  147.   if ((um & S_IROTH) == 0)
  148.     obits[i++] = 'r';
  149.   if ((um & S_IWOTH) == 0)
  150.     obits[i++] = 'w';
  151.   if ((um & S_IXOTH) == 0)
  152.     obits[i++] = 'x';
  153.   obits[i] = '\0';
  154.  
  155.   printf ("u=%s,g=%s,o=%s\n", ubits, gbits, obits);
  156. }
  157.  
  158. /* Set the umask from a symbolic mode string similar to that accepted
  159.    by chmod.  If the -S argument is given, then print the umask in a
  160.    symbolic form. */
  161. static int
  162. symbolic_umask (list)
  163.      WORD_LIST *list;
  164. {
  165.   int um, umc, c;
  166.   int who, op, perm, mask;
  167.   char *s;
  168.  
  169.   /* Get the initial umask.  Don't change it yet. */
  170.   um = umask (022);
  171.   umask (um);
  172.  
  173.   /* All work below is done with the complement of the umask -- its
  174.      more intuitive and easier to deal with.  It is complemented
  175.      again before being returned. */
  176.   umc = ~um;
  177.  
  178.   s = list->word->word;
  179.  
  180.   for (;;)
  181.     {
  182.       who = op = perm = mask = 0;
  183.  
  184.       /* Parse the `who' portion of the symbolic mode clause. */
  185.       while (member (*s, "agou"))
  186.         {
  187.       switch (c = *s++)
  188.         {
  189.           case 'u':
  190.             who |= S_IRWXU;
  191.             continue;
  192.           case 'g':
  193.             who |= S_IRWXG;
  194.             continue;
  195.           case 'o':
  196.             who |= S_IRWXO;
  197.             continue;
  198.           case 'a':
  199.             who |= S_IRWXU | S_IRWXG | S_IRWXO;
  200.             continue;
  201.           default:
  202.             break;
  203.         }
  204.     }
  205.  
  206.       /* The operation is now sitting in *s. */
  207.       op = *s++;
  208.       switch (op)
  209.     {
  210.       case '+':
  211.       case '-':
  212.       case '=':
  213.         break;
  214.       default:
  215.         builtin_error ("bad symbolic mode operator: %c", op);
  216.         return (-1);
  217.     }
  218.  
  219.       /* Parse out the `perm' section of the symbolic mode clause. */
  220.       while (member (*s, "rwx"))
  221.     {
  222.       c = *s++;
  223.  
  224.       switch (c)
  225.         {
  226.           case 'r':
  227.         perm |= S_IRUGO;
  228.         break;
  229.  
  230.           case 'w':
  231.         perm |= S_IWUGO;
  232.         break;
  233.  
  234.           case 'x':
  235.         perm |= S_IXUGO;
  236.         break;
  237.         }
  238.     }
  239.  
  240.       /* Now perform the operation or return an error for a
  241.      bad permission string. */
  242.       if (!*s || *s == ',')
  243.     {
  244.       if (who)
  245.         perm &= who;
  246.  
  247.       switch (op)
  248.         {
  249.           case '+':
  250.             umc |= perm;
  251.             break;
  252.  
  253.           case '-':
  254.             umc &= ~perm;
  255.             break;
  256.  
  257.           case '=':
  258.             umc &= ~who;
  259.             umc |= perm;
  260.             break;
  261.  
  262.           default:
  263.               builtin_error ("bad operation character: %c", op);
  264.               return (-1);
  265.         }
  266.  
  267.       if (!*s)
  268.         {
  269.           um = ~umc & 0777;
  270.           break;
  271.         }
  272.       else
  273.         s++;    /* skip past ',' */
  274.     }
  275.       else
  276.     {
  277.       builtin_error ("bad character in symbolic mode: %c", *s);
  278.       return (-1);
  279.     }
  280.     }
  281.   return (um);
  282. }
  283.  
  284.